Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

Q is empty.


QTRS
  ↳ Overlay + Local Confluence

Q restricted rewrite system:
The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

Q is empty.

The TRS is overlay and locally confluent. By [19] we can switch to innermost.

↳ QTRS
  ↳ Overlay + Local Confluence
QTRS
      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)


Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y) → LE(y, s(0))
IF(false, b1, b2, b3, x, y) → P(x)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))
LE(s(x), s(y)) → LE(x, y)
IF4(false, x, y) → P(y)
IF4(false, x, y) → P(p(y))
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → LE(x, 0)
AVERAGE(x, y) → LE(y, 0)
AVERAGE(x, y) → LE(y, s(s(0)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
QDP
          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y) → LE(y, s(0))
IF(false, b1, b2, b3, x, y) → P(x)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))
LE(s(x), s(y)) → LE(x, y)
IF4(false, x, y) → P(y)
IF4(false, x, y) → P(p(y))
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → LE(x, 0)
AVERAGE(x, y) → LE(y, 0)
AVERAGE(x, y) → LE(y, s(s(0)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 7 less nodes.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
QDP
                ↳ UsableRulesProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ UsableRulesProof
QDP
                    ↳ QReductionProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

R is empty.
The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
QDP
                        ↳ QDPSizeChangeProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
QDP
                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
QDP
                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables s(s(0)) is replaced by the fresh variable x_removed.
Pair: AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
Positions in right side of the pair: The new variable was added to all pairs as a new argument[13].

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
QDP
                        ↳ RemovalProof
                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y, x_removed) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, x_removed), x, y, x_removed)
IF(true, b1, b2, b3, x, y, x_removed) → IF2(b1, b2, b3, x, y, x_removed)
IF4(false, x, y, x_removed) → AVERAGE(s(x), p(p(y)), x_removed)
IF(false, b1, b2, b3, x, y, x_removed) → AVERAGE(p(x), s(y), x_removed)
IF3(false, b3, x, y, x_removed) → IF4(b3, x, y, x_removed)
IF2(false, b2, b3, x, y, x_removed) → IF3(b2, b3, x, y, x_removed)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables s(s(0)) is replaced by the fresh variable x_removed.
Pair: AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
Positions in right side of the pair: The new variable was added to all pairs as a new argument[13].

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
QDP
                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y, x_removed) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, x_removed), x, y, x_removed)
IF(true, b1, b2, b3, x, y, x_removed) → IF2(b1, b2, b3, x, y, x_removed)
IF4(false, x, y, x_removed) → AVERAGE(s(x), p(p(y)), x_removed)
IF(false, b1, b2, b3, x, y, x_removed) → AVERAGE(p(x), s(y), x_removed)
IF3(false, b3, x, y, x_removed) → IF4(b3, x, y, x_removed)
IF2(false, b2, b3, x, y, x_removed) → IF3(b2, b3, x, y, x_removed)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y) at position [0] we obtained the following new rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
QDP
                            ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y)) at position [0] we obtained the following new rules:

IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF(false, y0, y1, y2, 0, y4) → AVERAGE(0, s(y4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
QDP
                                ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF(false, y0, y1, y2, 0, y4) → AVERAGE(0, s(y4))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
QDP
                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1) we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
QDP
                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, s(z4)) → IF(true, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(z4)) → IF(true, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4)) at position [1] we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, false, le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
QDP
                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
AVERAGE(0, s(z4)) → IF(true, false, le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(z4)) → IF(true, false, le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4)) at position [2] we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(s(z4), s(s(0))), 0, s(z4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
QDP
                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(s(z4), s(s(0))), 0, s(z4))
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(s(z4), s(s(0))), 0, s(z4)) at position [3] we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
QDP
                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y) we obtained the following new rules:

IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
QDP
                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y) we obtained the following new rules:

IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
QDP
                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(false, b3, x, y) → IF4(b3, x, y) we obtained the following new rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
QDP
                                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF4(false, x, y) → AVERAGE(s(x), p(p(y))) we obtained the following new rules:

IF4(false, 0, s(z1)) → AVERAGE(s(0), p(p(s(z1))))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
QDP
                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(p(s(z1))))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF4(false, 0, s(z1)) → AVERAGE(s(0), p(p(s(z1)))) at position [1,0] we obtained the following new rules:

IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
QDP
                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1) we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
QDP
                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
AVERAGE(s(x0), s(z4)) → IF(false, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4)) at position [1] we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, false, le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
QDP
                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(z4)) → IF(false, false, le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, false, le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4)) at position [2] we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(s(z4), s(s(0))), s(x0), s(z4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
QDP
                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(s(z4), s(s(0))), s(x0), s(z4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(s(z4), s(s(0))), s(x0), s(z4)) at position [3] we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
QDP
                                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4)) we obtained the following new rules:

IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
QDP
                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4)) we obtained the following new rules:

AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, le(s(z3), 0), le(s(z3), s(0)), s(x0), s(s(z3)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
QDP
                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, le(s(z3), 0), le(s(z3), s(0)), s(x0), s(s(z3)))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(s(z3))) → IF(false, false, le(s(z3), 0), le(s(z3), s(0)), s(x0), s(s(z3))) at position [2] we obtained the following new rules:

AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(s(z3), s(0)), s(x0), s(s(z3)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
QDP
                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(s(z3), s(0)), s(x0), s(s(z3)))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(s(z3), s(0)), s(x0), s(s(z3))) at position [3] we obtained the following new rules:

AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
QDP
                                                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1))) we obtained the following new rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
QDP
                                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2)) we obtained the following new rules:

IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
QDP
                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0)) we obtained the following new rules:

IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
QDP
                                                                                                                    ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4)) at position [2] we obtained the following new rules:

AVERAGE(0, s(0)) → IF(true, false, true, le(0, s(0)), 0, s(0))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
QDP
                                                                                                                        ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
AVERAGE(0, s(0)) → IF(true, false, true, le(0, s(0)), 0, s(0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
QDP
                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0))) at position [3] we obtained the following new rules:

AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
QDP
                                                                                                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2)) we obtained the following new rules:

IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2)) we obtained the following new rules:

IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2)) we obtained the following new rules:

IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
QDP
                                                                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1)) we obtained the following new rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1)))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
QDP
                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1)))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1))) at position [1] we obtained the following new rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
QDP
                                                                                                                                                        ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

p(s(x)) → x
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
QDP
                                                                                                                                                            ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

p(s(x0))
p(0)



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
QDP
                                                                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0)) we obtained the following new rules:

IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
QDP
                                                                                                                                                                    ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1))) we obtained the following new rules:

IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
QDP
                                                                                                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1))) we obtained the following new rules:

IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
QDP
                                                                                                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0))) we obtained the following new rules:

IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
QDP
                                                                                                                                                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0))) at position [3] we obtained the following new rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(0, s(s(0))) → IF(true, false, false, true, 0, s(s(0)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(0, s(s(0))) → IF(true, false, false, true, 0, s(s(0)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0) we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, le(s(y_4), 0), le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
QDP
                                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(y_4)) → IF(false, le(s(y_4), 0), le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(y_4)) → IF(false, le(s(y_4), 0), le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4)) at position [1] we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
QDP
                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [1] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
QDP
                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4)) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
QDP
                                                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
QDP
                                                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4)) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(y_4, s(0)), s(0), s(y_4))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
QDP
                                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
QDP
                                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(y_5), s(0)), s(0), s(s(y_5)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
QDP
                                                                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(y_5), s(0)), s(0), s(s(y_5)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(y_5), s(0)), s(0), s(s(y_5))) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
QDP
                                                                                                                                                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0))) we obtained the following new rules:

IF(false, false, y_0, y_1, s(0), s(z0)) → AVERAGE(0, s(s(z0)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1) we obtained the following new rules:

IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3))) we obtained the following new rules:

IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1)))) we obtained the following new rules:

IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(false, false, false, x0, s(0), s(s(x2))) → AVERAGE(0, s(s(s(x2))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1)) we obtained the following new rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, le(s(y_4), 0), le(s(y_4), s(0)), s(0), s(s(y_4)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(0), s(s(y_4))) → IF(false, false, le(s(y_4), 0), le(s(y_4), s(0)), s(0), s(s(y_4)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_4))) → IF(false, false, le(s(y_4), 0), le(s(y_4), s(0)), s(0), s(s(y_4))) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(s(y_4), s(0)), s(0), s(s(y_4)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
QDP
                                                                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(s(y_4), s(0)), s(0), s(s(y_4)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(s(y_4), s(0)), s(0), s(s(y_4))) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(y_4, 0), s(0), s(s(y_4)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof
QDP
                                                                                                                                                                                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0)))) we obtained the following new rules:

IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3))) we obtained the following new rules:

AVERAGE(s(s(y_4)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(y_4)), s(s(x1)))
AVERAGE(s(s(0)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(0)), s(s(x1)))
AVERAGE(s(0), s(s(x1))) → IF(false, false, false, le(x1, 0), s(0), s(s(x1)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(s(0)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(0)), s(s(x1)))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(s(y_4)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(y_4)), s(s(x1)))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ AND
QDP
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                        ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0)) we obtained the following new rules:

IF4(false, 0, s(s(s(s(y_0))))) → AVERAGE(s(0), s(s(y_0)))



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ AND
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                              ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
The remaining pairs can at least be oriented weakly.

IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(AVERAGE(x1, x2)) = x1 + x2   
POL(IF(x1, x2, x3, x4, x5, x6)) = x5 + x6   
POL(IF2(x1, x2, x3, x4, x5)) = x5   
POL(IF3(x1, x2, x3, x4)) = x4   
POL(IF4(x1, x2, x3)) = x3   
POL(false) = 0   
POL(le(x1, x2)) = 0   
POL(s(x1)) = 1 + x1   
POL(true) = 0   

The following usable rules [17] were oriented: none



↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ AND
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ QDPOrderProof
QDP
                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 6 less nodes.

↳ QTRS
  ↳ Overlay + Local Confluence
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ RemovalProof
                        ↳ RemovalProof
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Instantiation
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Instantiation
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ Instantiation
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Instantiation
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Instantiation
                                                                                          ↳ QDP
                                                                                            ↳ Instantiation
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Instantiation
                                                                                                          ↳ QDP
                                                                                                            ↳ ForwardInstantiation
                                                                                                              ↳ QDP
                                                                                                                ↳ ForwardInstantiation
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Narrowing
                                                                                                                      ↳ QDP
                                                                                                                        ↳ DependencyGraphProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Rewriting
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ ForwardInstantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ ForwardInstantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ ForwardInstantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ AND
                                                                                                                                                                                                                                                                        ↳ QDP
QDP
                                                                                                                                                                                                                                                                          ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(s(y_4)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(y_4)), s(s(x1)))
AVERAGE(s(s(0)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(0)), s(s(x1)))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: